home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Multimedia / Resource Library: Multimedia.iso / maestro / source / dtr / gbcanvas.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-15  |  16.6 KB  |  513 lines
  1. /*
  2.  * Copyright (c) 1990, 1991 Stanford University
  3.  *
  4.  * Permission to use, copy, modify, and distribute this software and 
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name
  8.  * Stanford may not be used in any advertising or publicity relating to
  9.  * the software without the specific, prior written permission of
  10.  * Stanford.
  11.  * 
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  13.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  14.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  15.  *
  16.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
  17.  * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES
  18.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT
  19.  * ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY,
  20.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21.  * SOFTWARE.
  22.  */
  23.  
  24. /* $Header: /Source/Media/collab/DTR/RCS/gbcanvas.c,v 1.10 92/01/09 12:42:06 drapeau Exp Locker: derek $ */
  25. /* $Log:    gbcanvas.c,v $
  26.  * Revision 1.10  92/01/09  12:42:06  drapeau
  27.  * Slight modifications to the code to make it ANSI-compliant.
  28.  * 
  29.  * Revision 1.0  92/01/06  17:55:07  drapeau
  30.  * Made a number of cosmetic changes to make code easier to read and
  31.  * to conform to programming specifications.
  32.  * 
  33.  * Revision 0.20  91/09/18  22:47:25  derek
  34.  * The following things are done:
  35.  * 1.    The Makefile is changed corresponding to the changes in collab/.
  36.  * 2.    Copyright messages included.
  37.  * 3.    Some minor bugs fixed.
  38.  * 
  39.  * Revision 0.19  91/08/27  18:06:05  derek
  40.  * The SizeToFit bug is fixed.
  41.  * 
  42.  * Revision 0.18  91/08/21  11:34:18  derek
  43.  * The following changes are made:
  44.  * 1.    Now the duration and size of the recorded sound will be displayed
  45.  *     during recording.
  46.  * 2.    I have changed GetSelection() corresponding to the request of Tek joo
  47.  * 3.    Info Panel is added to the application.
  48.  * 4.    Fixed SizeToFitHandler() so that when no file or buffer is currently
  49.  *     loaded, it would not do anything (except giving a warning
  50.  *     notice_prompt).
  51.  * 5.    Inplemented the `Close' Menu option in the document menu.
  52.  * 6.    Fixed the bug in which after ClearAll and I press PreviewEdit,
  53.  *     the edit wont be played.
  54.  * 7.    I have made the changes corresponding to the change in OpenPanel's
  55.  *     name.  (from OpenPanel to Browse).
  56.  * 8.    Incorporated BrowseCheck to check command line arg.
  57.  * 9.    Changed most EditingStatusMessages to NoticePrompts.
  58.  * 10.    SoundFileSaveAsPopUp and EditListSaveAsPopUp are removed 
  59.  *     from the application.
  60.  * 
  61.  * Revision 0.17  91/08/08  21:44:37  derek
  62.  * Fixed a number of bugs.
  63.  * 
  64.  * Revision 0.16  91/08/08  11:02:12  derek
  65.  * This is a cleaner version.  I have removed lots of printf/fprintf 
  66.  * statements from it, and have also cleaned up the code using xsaber.
  67.  * This version should run substantially faster.
  68.  * 
  69.  * Revision 0.15  91/08/07  16:24:15  derek
  70.  * The Edit list part of DTR is done.  OpenPanel is also incorporated.
  71.  * 
  72.  * Revision 0.14  91/07/23  21:22:48  derek
  73.  * This version is not ready for release.  Disk space editing is half-done:
  74.  * the application can play an infinite sound and the canvases can handle
  75.  * infinite sound files.  The app is pretty bug free too, I think.  The
  76.  * weakness is that it cannot record sond infinitely.
  77.  * 
  78.  * Revision 0.13  91/06/26  15:55:07  derek
  79.  * I have reformatted the code to conform coding specs.
  80.  * 
  81.  * Revision 0.12  91/06/20  20:00:42  derek
  82.  * The network part should be working.  Also fixed a number of bugs involving
  83.  * canvases and display.
  84.  * 
  85.  * Revision 0.11  91/06/05  14:59:53  derek
  86.  * checking in after porting the code to collab
  87.  * 
  88.  * Revision 0.10  1991/04/25  01:48:26  derek
  89.  * This version is checked in on 4/24/91
  90.  * */
  91. static char rcsid[] = "$Header: /Source/Media/collab/DTR/RCS/gbcanvas.c,v 1.10 92/01/09 12:42:06 drapeau Exp Locker: derek $";
  92.  
  93. #include "dtr.h"
  94. #include "dtr_ui.h"
  95.  
  96. /*
  97.  * Various Windows.
  98.  */
  99. extern  dtr_globalWaveCanvasPopUp_objects    *dtr_globalWaveCanvasPopUp;
  100.  
  101. /*
  102.  * Global variables for Global Wave Canvas;
  103.  */
  104. Window         xidGbWave;
  105. Xv_Window      paintWinGbWave;
  106. Display        *dpyGbWave;
  107. GC             gcGbWave;
  108. unsigned long *    GlobalWaveCanvasColormap;
  109.  
  110. extern     int    ScrollbarViewStart;
  111. extern    int    ScrollbarViewEnd;
  112.  
  113.  
  114. void
  115.   InitGlobalWaveCanvas()
  116. {
  117.   Xv_opaque       gwcanvas = dtr_globalWaveCanvasPopUp->globalWaveCanvas;
  118.   
  119.   EVENT("Init_Global_Wave_Canvas");
  120.   
  121.   paintWinGbWave = canvas_paint_window(gwcanvas);
  122.   xidGbWave = (Window) xv_get(paintWinGbWave, XV_XID);
  123.   dpyGbWave = (Display *) xv_get(gwcanvas, XV_DISPLAY);
  124.   gcGbWave = XCreateGC(dpyGbWave, xidGbWave, 0, 0);
  125.   
  126.   xv_set(paintWinGbWave, WIN_CONSUME_EVENTS, WIN_NO_EVENTS,        /*  Specifies that only the left- and the right-... */
  127.      WIN_ASCII_EVENTS,                        /*  ...button events will be registered, in fact... */
  128.      LOC_DRAG, MS_LEFT,                        /*  ...useless because middle button events will... */
  129.      MS_MIDDLE, NULL, NULL);                    /*  ...anyways.                                     */
  130.   
  131.   GlobalWaveCanvasColormap = GetColormap(gwcanvas);            /*  Get Colormap.                                   */
  132.   XSetForeground(dpyGbWave, gcGbWave, 
  133.          GetColorIndex(GlobalWaveCanvasColormap, "White"));
  134.   
  135.   oldLeftFloatGbWaveMarker = -1.0;                    /*  Init left and right wave canvas markers.        */
  136.   oldRightFloatGbWaveMarker = -1.0;
  137.   GlobalWaveCanvasRightMarkerSet = FALSE;
  138.   
  139.   GlobalWaveCanvasWidth = (int) xv_get(gwcanvas, CANVAS_WIDTH, NULL);
  140.   GlobalWaveCanvasHeight = (int) xv_get(gwcanvas, CANVAS_HEIGHT, NULL);
  141.   GlobalWaveWindowWidth = (int) xv_get(gwcanvas, XV_WIDTH, NULL);
  142.   GlobalWaveWindowHeight = (int) xv_get(gwcanvas, XV_HEIGHT, NULL);
  143.   GlobalWaveCanvasMidHeight = GlobalWaveCanvasHeight/2;
  144.   GlobalWaveScopeWidth = GlobalWaveCanvasMidHeight - 4;
  145.   GlobalWaveCanvasInitReady = TRUE;
  146.   GbWaveLeftButtonHoldPoint = NOTREADY;
  147. }                                    /* end function InitGlobalWaveCanvas */
  148.  
  149.  
  150. void
  151.   RepaintGlobalWaveCanvas()
  152. {
  153.   EVENT("Repaint_Global_Wave_Canvas");
  154.   
  155.   GlobalWaveCanvasRepaintHandler(
  156.                  (Canvas)dtr_globalWaveCanvasPopUp->globalWaveCanvas,
  157.                  paintWinGbWave, 
  158.                  (Display *)dpyGbWave,
  159.                  xidGbWave, NULL);
  160. }
  161.  
  162.  
  163. /*
  164.  *  Clear Wave Canvas, reset the scrollbars.
  165.  */
  166. void
  167.   ResetGlobalWaveCanvas()
  168. {
  169.   ClearGlobalWaveCanvas();                        /*  Clear Global Wave Canvas.                       */
  170.   oldLeftFloatGbWaveMarker = oldRightFloatGbWaveMarker = -1.0;        /*  Reset Various Selection Parameters.             */
  171.   GlobalWaveCanvasRightMarkerSet = FALSE;
  172.   GbWaveLeftButtonHoldPoint = NOTREADY;
  173. }
  174.  
  175.  
  176.  
  177. void
  178.   ClearGlobalWaveCanvas()
  179. {
  180.   extern   GC gcGbWave;
  181.   
  182.   XClearWindow(dpyGbWave, xidGbWave);
  183.   XSetForeground(dpyGbWave, gcGbWave, 
  184.          GetColorIndex(GlobalWaveCanvasColormap, "White"));
  185.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave, 0, GlobalWaveCanvasMidHeight,
  186.         GlobalWaveCanvasWidth-1, GlobalWaveCanvasMidHeight);
  187.   
  188.   oldLeftFloatGbWaveMarker = oldRightFloatGbWaveMarker = 0.0;        /*  Clear Markers.                                  */
  189. }
  190.  
  191.  
  192. /*
  193.  *  Check if the user has clicked the mouse at a place outside
  194.  *  the scope of the soundbuffer.
  195.  */
  196. BOOL
  197.   GlobalWaveCanvasOutOfSoundScope(winX)
  198. int winX;
  199. {
  200.   int bufferX;
  201.   
  202.   if (GlobalWaveCanvasDataSamplingInterval == 0.0)
  203.     return (TRUE);
  204.   
  205.   bufferX = irint(winX * GlobalWaveCanvasDataSamplingInterval);
  206.   
  207.   if (bufferX > Buffer.hdr.data_size || bufferX < 0)
  208.     return(TRUE);
  209.   return(FALSE);
  210. }
  211.  
  212.  
  213. void
  214.   GlobalWaveCanvasMarkerHandler(winX, oldmarker)
  215. int winX;
  216. double *oldmarker;
  217. {
  218.   int     oldLeftWinX, oldRightWinX, LeftWinX, RightWinX;
  219.   
  220.   EVENT("Global_Wave_Canvas_Marker_Handler");
  221.   
  222.   if (GlobalWaveCanvasOutOfSoundScope(winX))
  223.     return;
  224.   
  225.   oldLeftWinX = irint( oldLeftFloatGbWaveMarker /            /*  Save old markers.                               */
  226.               GlobalWaveCanvasDataSamplingInterval );
  227.   oldRightWinX = irint( oldRightFloatGbWaveMarker / 
  228.                GlobalWaveCanvasDataSamplingInterval );
  229.   
  230.   if (oldmarker == &oldLeftFloatGbWaveMarker)                /*  Left button or right button pressed.            */
  231.   {
  232.     oldLeftFloatGbWaveMarker = oldRightFloatGbWaveMarker = 
  233.       winX * GlobalWaveCanvasDataSamplingInterval;
  234.   } 
  235.   else
  236.   {
  237.     oldRightFloatGbWaveMarker = winX * 
  238.       GlobalWaveCanvasDataSamplingInterval;
  239.   }
  240.   
  241.   LeftWinX = irint( oldLeftFloatGbWaveMarker /                /*  Draw Markers.                                   */
  242.            GlobalWaveCanvasDataSamplingInterval );
  243.   RightWinX = irint( oldRightFloatGbWaveMarker / 
  244.             GlobalWaveCanvasDataSamplingInterval );
  245.   
  246.   if (!GlobalWaveCanvasRightMarkerSet && oldmarker == &oldRightFloatGbWaveMarker)
  247.     ReverseGlobalWaveCanvasArea(winX, winX);
  248.   
  249.   if (LeftWinX > oldRightWinX || RightWinX < oldLeftWinX) 
  250.   {      
  251.     if (GlobalWaveCanvasRightMarkerSet)
  252.     {
  253.       ReverseGlobalWaveCanvasArea(oldLeftWinX, oldRightWinX);
  254.       if (oldmarker == &oldLeftFloatGbWaveMarker)
  255.     ReverseGlobalWaveCanvasArea(winX, winX);
  256.     }
  257.   }
  258.   else if (GlobalWaveCanvasRightMarkerSet)
  259.   {
  260.     if (LeftWinX > oldLeftWinX /***&& oldLeftWinX != 0 ***/)
  261.     {
  262.       ReverseGlobalWaveCanvasArea(oldLeftWinX, LeftWinX-1);
  263.     } 
  264.     else if (LeftWinX < oldLeftWinX)
  265.     {
  266.       ReverseGlobalWaveCanvasArea(LeftWinX, oldLeftWinX-1);
  267.     }
  268.     
  269.     if (RightWinX > oldRightWinX)
  270.     {
  271.       ReverseGlobalWaveCanvasArea(oldRightWinX + 1, RightWinX);
  272.     } 
  273.     else if (RightWinX < oldRightWinX)
  274.     {
  275.       ReverseGlobalWaveCanvasArea(RightWinX + 1, oldRightWinX);
  276.     }
  277.   }
  278.   
  279.   if (oldmarker == &oldRightFloatGbWaveMarker)
  280.     GlobalWaveCanvasRightMarkerSet = TRUE;
  281.   
  282.   Buffer.play.start = irint(oldLeftFloatGbWaveMarker);            /*  Update start and end points.                    */
  283.   Buffer.play.end = irint(oldRightFloatGbWaveMarker);
  284.   
  285.   UpdateMessageDisplay();                        /*  Update message display (sound selection size... */
  286.                                     /*  ...and duration etc.)                           */
  287. }                                    /* end function GlobalWaveCanvasMarkerHandler */
  288.  
  289.  
  290. /*
  291.  *  Takes cares of case when user tries to drag leftwards (instead of 
  292.  *  rightwards).
  293.  */
  294. void
  295.   GlobalWaveCanvasBackwardMarkerHandler(winX, oldmarker)
  296. int  winX;
  297. double *oldmarker;
  298. {
  299.   int     oldLeftWinX, oldRightWinX, LeftWinX, RightWinX;
  300.   
  301.   EVENT("Global_Wave_Canvas_Backward_Marker_Handler");
  302.   
  303.   if (GlobalWaveCanvasOutOfSoundScope(winX))
  304.     return;
  305.   
  306.   oldLeftWinX = irint( oldLeftFloatGbWaveMarker /            /*  Save old markers.                               */
  307.               GlobalWaveCanvasDataSamplingInterval );
  308.   oldRightWinX = irint( oldRightFloatGbWaveMarker / 
  309.                GlobalWaveCanvasDataSamplingInterval );
  310.   
  311.   if (oldmarker == &oldLeftFloatGbWaveMarker)                /*  Left button or right button pressed.            */
  312.   {
  313.     oldLeftFloatGbWaveMarker = winX * 
  314.       GlobalWaveCanvasDataSamplingInterval;
  315.   } 
  316.   
  317.   LeftWinX = irint( oldLeftFloatGbWaveMarker /                /*  Draw markers.                                   */
  318.            GlobalWaveCanvasDataSamplingInterval );
  319.   RightWinX = irint( oldRightFloatGbWaveMarker / 
  320.             GlobalWaveCanvasDataSamplingInterval );
  321.   
  322.   if (!GlobalWaveCanvasRightMarkerSet && oldmarker == 
  323.       &oldRightFloatGbWaveMarker)
  324.     ReverseGlobalWaveCanvasArea(winX, winX);
  325.   
  326.   if (LeftWinX > oldRightWinX || RightWinX < oldLeftWinX)
  327.   {
  328.     if (GlobalWaveCanvasRightMarkerSet)
  329.       ReverseGlobalWaveCanvasArea(oldLeftWinX, oldRightWinX);
  330.     if (oldmarker == &oldLeftFloatGbWaveMarker)
  331.       ReverseGlobalWaveCanvasArea(winX, winX);
  332.   }
  333.   else if (GlobalWaveCanvasRightMarkerSet)
  334.   {
  335.     if (LeftWinX > oldLeftWinX && oldLeftWinX != 0)
  336.     {
  337.       ReverseGlobalWaveCanvasArea(oldLeftWinX, LeftWinX-1);
  338.     } 
  339.     else if (LeftWinX < oldLeftWinX)
  340.     {
  341.       ReverseGlobalWaveCanvasArea(LeftWinX, oldLeftWinX-1);
  342.     }
  343.     
  344.     if (RightWinX > oldRightWinX)
  345.     {
  346.       ReverseGlobalWaveCanvasArea(oldRightWinX + 1, RightWinX);
  347.     } 
  348.     else if (RightWinX < oldRightWinX)
  349.     {
  350.       ReverseGlobalWaveCanvasArea(RightWinX + 1, oldRightWinX);
  351.     }
  352.   }
  353.   
  354.   GlobalWaveCanvasRightMarkerSet = TRUE;
  355.   
  356.   Buffer.play.start = irint(oldLeftFloatGbWaveMarker);            /*  Update start and end points.                    */
  357.   Buffer.play.end = irint(oldRightFloatGbWaveMarker);
  358.   
  359.   UpdateMessageDisplay();                        /*  update message display (sound selection size... */
  360.                                     /*  ...and duration).                               */
  361. }                                    /* end function GlobalWaveCanvasBackwardMarkerHandler */
  362.  
  363.  
  364. /*
  365.  *  Set Foreground color of GlobalWave canvas.
  366.  */
  367. void
  368.   GlobalWaveCanvasPenColor(colorStr)
  369. char *colorStr;
  370. {
  371.   XSetForeground(dpyGbWave, gcGbWave, 
  372.          GetColorIndex(GlobalWaveCanvasColormap, colorStr));
  373. }
  374.  
  375.  
  376. /*
  377.  *  This function is called when user selects "Reset Markers"
  378.  *  from the function menu.
  379.  */
  380. void
  381.   ResetGlobalWaveCanvasMarkers()
  382. {
  383.   EVENT("Reset_Global_Wave_Canvas_Markers");
  384.   
  385.   ReverseGlobalWaveCanvasArea(
  386.                   irint(oldLeftFloatGbWaveMarker/
  387.                     GlobalWaveCanvasDataSamplingInterval),
  388.                   irint(oldRightFloatGbWaveMarker/
  389.                     GlobalWaveCanvasDataSamplingInterval));
  390.   GlobalWaveCanvasRightMarkerSet = FALSE;
  391.   GbWaveLeftButtonHoldPoint = NOTREADY;
  392.   UpdateMessageDisplay();
  393.   Buffer.play.start = 0;
  394.   Buffer.play.end = Buffer.hdr.data_size - 1;
  395. }
  396.  
  397.  
  398. /*
  399.  *  For Highlighting or Unhighlighting a portion of the canvas.
  400.  */
  401. void
  402.   ReverseGlobalWaveCanvasArea(left, right)
  403. int  left, right;
  404. {
  405.   XSetFunction(dpyGbWave, gcGbWave, GXinvert);
  406.   XFillRectangle(dpyGbWave, xidGbWave, gcGbWave, 
  407.          left, 0,
  408.          right - left + 1, GlobalWaveWindowHeight - 1);
  409.   XSetFunction(dpyGbWave, gcGbWave, GXcopy);
  410. }
  411.  
  412.  
  413. /*
  414.  *  This routine takes care of the local wave canvas frame within
  415.  *  the global wave canvas.
  416.  */
  417. void
  418.   UpdateCanvasFrame()
  419. {
  420.   int                   newViewStart;
  421.   int                newViewEnd;
  422.   extern        int     ScrollbarPixelsPerUnit;
  423.   extern Scrollbar      WaveCanvasScrollbar;
  424.   
  425.   XSetFunction(dpyGbWave, gcGbWave, GXxor);
  426.   GlobalWaveCanvasPenColor("red");
  427.   
  428.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave, 
  429.         ScrollbarViewStart, 0+5, 
  430.         ScrollbarViewStart, WaveWindowHeight-1-8);
  431.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  432.         ScrollbarViewEnd, 0+5, 
  433.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  434.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  435.         ScrollbarViewStart, 0+5, 
  436.         ScrollbarViewEnd, 0+5);
  437.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  438.         ScrollbarViewStart, WaveWindowHeight-1-8,
  439.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  440.   
  441.   newViewStart = irint((FrameStartingSecond / 10.0) *
  442.                WaveCanvasWidth +
  443.                (ScrollbarPixelsPerUnit *
  444.             xv_get(WaveCanvasScrollbar, SCROLLBAR_VIEW_START)));
  445.   
  446.   newViewEnd = newViewStart + WaveWindowWidth - 1;
  447.   
  448.   ScrollbarViewStart = irint(newViewStart * WaveCanvasDataSamplingInterval
  449.                  / GlobalWaveCanvasDataSamplingInterval);
  450.   ScrollbarViewEnd = irint(newViewEnd * WaveCanvasDataSamplingInterval
  451.                / GlobalWaveCanvasDataSamplingInterval);
  452.   
  453.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave, 
  454.         ScrollbarViewStart, 0+5, 
  455.         ScrollbarViewStart, WaveWindowHeight-1-8);
  456.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  457.         ScrollbarViewEnd, 0+5, 
  458.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  459.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  460.         ScrollbarViewStart, 0+5, 
  461.         ScrollbarViewEnd, 0+5);
  462.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  463.         ScrollbarViewStart, WaveWindowHeight-1-8,
  464.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  465.   
  466.   XSetFunction(dpyGbWave, gcGbWave, GXcopy);
  467. }                                    /* end function UpdateCanvasFrame */
  468.  
  469. void
  470.   DisplayCanvasFrame()
  471. {
  472.   extern   Scrollbar     WaveCanvasScrollbar;
  473.   extern   int           ScrollbarPixelsPerUnit;
  474.   int                    frameStart;
  475.   int                    frameEnd;
  476.   
  477.   XSetFunction(dpyGbWave, gcGbWave, GXxor);
  478.   GlobalWaveCanvasPenColor("red");
  479.   
  480.   frameStart = ScrollbarPixelsPerUnit * 
  481.     xv_get(WaveCanvasScrollbar, SCROLLBAR_VIEW_START, NULL);
  482.   frameEnd = frameStart + WaveWindowWidth-1;
  483.   
  484.   if (GlobalWaveCanvasDataSamplingInterval != 0.0)
  485.   {
  486.     ScrollbarViewStart = irint(frameStart * WaveCanvasDataSamplingInterval
  487.                    / GlobalWaveCanvasDataSamplingInterval);
  488.     ScrollbarViewEnd = irint(frameEnd * WaveCanvasDataSamplingInterval
  489.                  / GlobalWaveCanvasDataSamplingInterval);
  490.   }
  491.   else
  492.   {
  493.     ScrollbarViewStart = 0;
  494.     ScrollbarViewEnd = 0;
  495.   }
  496.   
  497.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave, 
  498.         ScrollbarViewStart, 0+5, 
  499.         ScrollbarViewStart, WaveWindowHeight-1-8);
  500.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  501.         ScrollbarViewEnd, 0+5, 
  502.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  503.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  504.         ScrollbarViewStart, 0+5, 
  505.         ScrollbarViewEnd, 0+5);
  506.   XDrawLine(dpyGbWave, xidGbWave, gcGbWave,
  507.         ScrollbarViewStart, WaveWindowHeight-1-8,
  508.         ScrollbarViewEnd, WaveWindowHeight-1-8);
  509.   
  510.   XSetFunction(dpyGbWave, gcGbWave, GXcopy);
  511. }    
  512.  
  513.